home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / ConfigParser.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  21KB  |  691 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. '''Configuration file parser.
  5.  
  6. A setup file consists of sections, lead by a "[section]" header,
  7. and followed by "name: value" entries, with continuations and such in
  8. the style of RFC 822.
  9.  
  10. The option values can contain format strings which refer to other values in
  11. the same section, or values in a special [DEFAULT] section.
  12.  
  13. For example:
  14.  
  15.     something: %(dir)s/whatever
  16.  
  17. would resolve the "%(dir)s" to the value of dir.  All reference
  18. expansions are done late, on demand.
  19.  
  20. Intrinsic defaults can be specified by passing them into the
  21. ConfigParser constructor as a dictionary.
  22.  
  23. class:
  24.  
  25. ConfigParser -- responsible for parsing a list of
  26.                 configuration files, and managing the parsed database.
  27.  
  28.     methods:
  29.  
  30.     __init__(defaults=None)
  31.         create the parser and specify a dictionary of intrinsic defaults.  The
  32.         keys must be strings, the values must be appropriate for %()s string
  33.         interpolation.  Note that `__name__\' is always an intrinsic default;
  34.         its value is the section\'s name.
  35.  
  36.     sections()
  37.         return all the configuration section names, sans DEFAULT
  38.  
  39.     has_section(section)
  40.         return whether the given section exists
  41.  
  42.     has_option(section, option)
  43.         return whether the given option exists in the given section
  44.  
  45.     options(section)
  46.         return list of configuration options for the named section
  47.  
  48.     read(filenames)
  49.         read and parse the list of named configuration files, given by
  50.         name.  A single filename is also allowed.  Non-existing files
  51.         are ignored.  Return list of successfully read files.
  52.  
  53.     readfp(fp, filename=None)
  54.         read and parse one configuration file, given as a file object.
  55.         The filename defaults to fp.name; it is only used in error
  56.         messages (if fp has no `name\' attribute, the string `<???>\' is used).
  57.  
  58.     get(section, option, raw=False, vars=None)
  59.         return a string value for the named option.  All % interpolations are
  60.         expanded in the return values, based on the defaults passed into the
  61.         constructor and the DEFAULT section.  Additional substitutions may be
  62.         provided using the `vars\' argument, which must be a dictionary whose
  63.         contents override any pre-existing defaults.
  64.  
  65.     getint(section, options)
  66.         like get(), but convert value to an integer
  67.  
  68.     getfloat(section, options)
  69.         like get(), but convert value to a float
  70.  
  71.     getboolean(section, options)
  72.         like get(), but convert value to a boolean (currently case
  73.         insensitively defined as 0, false, no, off for False, and 1, true,
  74.         yes, on for True).  Returns False or True.
  75.  
  76.     items(section, raw=False, vars=None)
  77.         return a list of tuples with (name, value) for each option
  78.         in the section.
  79.  
  80.     remove_section(section)
  81.         remove the given file section and all its options
  82.  
  83.     remove_option(section, option)
  84.         remove the given option from the given section
  85.  
  86.     set(section, option, value)
  87.         set the given option
  88.  
  89.     write(fp)
  90.         write the configuration state in .ini format
  91. '''
  92. import re
  93. __all__ = [
  94.     'NoSectionError',
  95.     'DuplicateSectionError',
  96.     'NoOptionError',
  97.     'InterpolationError',
  98.     'InterpolationDepthError',
  99.     'InterpolationSyntaxError',
  100.     'ParsingError',
  101.     'MissingSectionHeaderError',
  102.     'ConfigParser',
  103.     'SafeConfigParser',
  104.     'RawConfigParser',
  105.     'DEFAULTSECT',
  106.     'MAX_INTERPOLATION_DEPTH']
  107. DEFAULTSECT = 'DEFAULT'
  108. MAX_INTERPOLATION_DEPTH = 10
  109.  
  110. class Error(Exception):
  111.     '''Base class for ConfigParser exceptions.'''
  112.     
  113.     def __init__(self, msg = ''):
  114.         self.message = msg
  115.         Exception.__init__(self, msg)
  116.  
  117.     
  118.     def __repr__(self):
  119.         return self.message
  120.  
  121.     __str__ = __repr__
  122.  
  123.  
  124. class NoSectionError(Error):
  125.     '''Raised when no section matches a requested option.'''
  126.     
  127.     def __init__(self, section):
  128.         Error.__init__(self, 'No section: %r' % (section,))
  129.         self.section = section
  130.  
  131.  
  132.  
  133. class DuplicateSectionError(Error):
  134.     '''Raised when a section is multiply-created.'''
  135.     
  136.     def __init__(self, section):
  137.         Error.__init__(self, 'Section %r already exists' % section)
  138.         self.section = section
  139.  
  140.  
  141.  
  142. class NoOptionError(Error):
  143.     '''A requested option was not found.'''
  144.     
  145.     def __init__(self, option, section):
  146.         Error.__init__(self, 'No option %r in section: %r' % (option, section))
  147.         self.option = option
  148.         self.section = section
  149.  
  150.  
  151.  
  152. class InterpolationError(Error):
  153.     '''Base class for interpolation-related exceptions.'''
  154.     
  155.     def __init__(self, option, section, msg):
  156.         Error.__init__(self, msg)
  157.         self.option = option
  158.         self.section = section
  159.  
  160.  
  161.  
  162. class InterpolationMissingOptionError(InterpolationError):
  163.     '''A string substitution required a setting which was not available.'''
  164.     
  165.     def __init__(self, option, section, rawval, reference):
  166.         msg = 'Bad value substitution:\n\tsection: [%s]\n\toption : %s\n\tkey    : %s\n\trawval : %s\n' % (section, option, reference, rawval)
  167.         InterpolationError.__init__(self, option, section, msg)
  168.         self.reference = reference
  169.  
  170.  
  171.  
  172. class InterpolationSyntaxError(InterpolationError):
  173.     '''Raised when the source text into which substitutions are made
  174.     does not conform to the required syntax.'''
  175.     pass
  176.  
  177.  
  178. class InterpolationDepthError(InterpolationError):
  179.     '''Raised when substitutions are nested too deeply.'''
  180.     
  181.     def __init__(self, option, section, rawval):
  182.         msg = 'Value interpolation too deeply recursive:\n\tsection: [%s]\n\toption : %s\n\trawval : %s\n' % (section, option, rawval)
  183.         InterpolationError.__init__(self, option, section, msg)
  184.  
  185.  
  186.  
  187. class ParsingError(Error):
  188.     '''Raised when a configuration file does not follow legal syntax.'''
  189.     
  190.     def __init__(self, filename):
  191.         Error.__init__(self, 'File contains parsing errors: %s' % filename)
  192.         self.filename = filename
  193.         self.errors = []
  194.  
  195.     
  196.     def append(self, lineno, line):
  197.         self.errors.append((lineno, line))
  198.         self.message += '\n\t[line %2d]: %s' % (lineno, line)
  199.  
  200.  
  201.  
  202. class MissingSectionHeaderError(ParsingError):
  203.     '''Raised when a key-value pair is found before any section header.'''
  204.     
  205.     def __init__(self, filename, lineno, line):
  206.         Error.__init__(self, 'File contains no section headers.\nfile: %s, line: %d\n%r' % (filename, lineno, line))
  207.         self.filename = filename
  208.         self.lineno = lineno
  209.         self.line = line
  210.  
  211.  
  212.  
  213. class RawConfigParser:
  214.     
  215.     def __init__(self, defaults = None):
  216.         self._sections = { }
  217.         self._defaults = { }
  218.         if defaults:
  219.             for key, value in defaults.items():
  220.                 self._defaults[self.optionxform(key)] = value
  221.             
  222.         
  223.  
  224.     
  225.     def defaults(self):
  226.         return self._defaults
  227.  
  228.     
  229.     def sections(self):
  230.         '''Return a list of section names, excluding [DEFAULT]'''
  231.         return self._sections.keys()
  232.  
  233.     
  234.     def add_section(self, section):
  235.         '''Create a new section in the configuration.
  236.  
  237.         Raise DuplicateSectionError if a section by the specified name
  238.         already exists.
  239.         '''
  240.         if section in self._sections:
  241.             raise DuplicateSectionError(section)
  242.         
  243.         self._sections[section] = { }
  244.  
  245.     
  246.     def has_section(self, section):
  247.         '''Indicate whether the named section is present in the configuration.
  248.  
  249.         The DEFAULT section is not acknowledged.
  250.         '''
  251.         return section in self._sections
  252.  
  253.     
  254.     def options(self, section):
  255.         '''Return a list of option names for the given section name.'''
  256.         
  257.         try:
  258.             opts = self._sections[section].copy()
  259.         except KeyError:
  260.             raise NoSectionError(section)
  261.  
  262.         opts.update(self._defaults)
  263.         if '__name__' in opts:
  264.             del opts['__name__']
  265.         
  266.         return opts.keys()
  267.  
  268.     
  269.     def read(self, filenames):
  270.         """Read and parse a filename or a list of filenames.
  271.  
  272.         Files that cannot be opened are silently ignored; this is
  273.         designed so that you can specify a list of potential
  274.         configuration file locations (e.g. current directory, user's
  275.         home directory, systemwide directory), and all existing
  276.         configuration files in the list will be read.  A single
  277.         filename may also be given.
  278.  
  279.         Return list of successfully read files.
  280.         """
  281.         if isinstance(filenames, basestring):
  282.             filenames = [
  283.                 filenames]
  284.         
  285.         read_ok = []
  286.         for filename in filenames:
  287.             
  288.             try:
  289.                 fp = open(filename)
  290.             except IOError:
  291.                 continue
  292.  
  293.             self._read(fp, filename)
  294.             fp.close()
  295.             read_ok.append(filename)
  296.         
  297.         return read_ok
  298.  
  299.     
  300.     def readfp(self, fp, filename = None):
  301.         """Like read() but the argument must be a file-like object.
  302.  
  303.         The `fp' argument must have a `readline' method.  Optional
  304.         second argument is the `filename', which if not given, is
  305.         taken from fp.name.  If fp has no `name' attribute, `<???>' is
  306.         used.
  307.  
  308.         """
  309.         if filename is None:
  310.             
  311.             try:
  312.                 filename = fp.name
  313.             except AttributeError:
  314.                 filename = '<???>'
  315.             except:
  316.                 None<EXCEPTION MATCH>AttributeError
  317.             
  318.  
  319.         None<EXCEPTION MATCH>AttributeError
  320.         self._read(fp, filename)
  321.  
  322.     
  323.     def get(self, section, option):
  324.         opt = self.optionxform(option)
  325.         if section not in self._sections:
  326.             if section != DEFAULTSECT:
  327.                 raise NoSectionError(section)
  328.             
  329.             if opt in self._defaults:
  330.                 return self._defaults[opt]
  331.             else:
  332.                 raise NoOptionError(option, section)
  333.         elif opt in self._sections[section]:
  334.             return self._sections[section][opt]
  335.         elif opt in self._defaults:
  336.             return self._defaults[opt]
  337.         else:
  338.             raise NoOptionError(option, section)
  339.  
  340.     
  341.     def items(self, section):
  342.         
  343.         try:
  344.             d2 = self._sections[section]
  345.         except KeyError:
  346.             if section != DEFAULTSECT:
  347.                 raise NoSectionError(section)
  348.             
  349.             d2 = { }
  350.  
  351.         d = self._defaults.copy()
  352.         d.update(d2)
  353.         if '__name__' in d:
  354.             del d['__name__']
  355.         
  356.         return d.items()
  357.  
  358.     
  359.     def _get(self, section, conv, option):
  360.         return conv(self.get(section, option))
  361.  
  362.     
  363.     def getint(self, section, option):
  364.         return self._get(section, int, option)
  365.  
  366.     
  367.     def getfloat(self, section, option):
  368.         return self._get(section, float, option)
  369.  
  370.     _boolean_states = {
  371.         '1': True,
  372.         'yes': True,
  373.         'true': True,
  374.         'on': True,
  375.         '0': False,
  376.         'no': False,
  377.         'false': False,
  378.         'off': False }
  379.     
  380.     def getboolean(self, section, option):
  381.         v = self.get(section, option)
  382.         if v.lower() not in self._boolean_states:
  383.             raise ValueError, 'Not a boolean: %s' % v
  384.         
  385.         return self._boolean_states[v.lower()]
  386.  
  387.     
  388.     def optionxform(self, optionstr):
  389.         return optionstr.lower()
  390.  
  391.     
  392.     def has_option(self, section, option):
  393.         '''Check for the existence of a given option in a given section.'''
  394.         if not section or section == DEFAULTSECT:
  395.             option = self.optionxform(option)
  396.             return option in self._defaults
  397.         elif section not in self._sections:
  398.             return False
  399.         else:
  400.             option = self.optionxform(option)
  401.             if not option in self._sections[section]:
  402.                 pass
  403.             return option in self._defaults
  404.  
  405.     
  406.     def set(self, section, option, value):
  407.         '''Set an option.'''
  408.         if not section or section == DEFAULTSECT:
  409.             sectdict = self._defaults
  410.         else:
  411.             
  412.             try:
  413.                 sectdict = self._sections[section]
  414.             except KeyError:
  415.                 raise NoSectionError(section)
  416.  
  417.         sectdict[self.optionxform(option)] = value
  418.  
  419.     
  420.     def write(self, fp):
  421.         '''Write an .ini-format representation of the configuration state.'''
  422.         if self._defaults:
  423.             fp.write('[%s]\n' % DEFAULTSECT)
  424.             for key, value in self._defaults.items():
  425.                 fp.write('%s = %s\n' % (key, str(value).replace('\n', '\n\t')))
  426.             
  427.             fp.write('\n')
  428.         
  429.         for section in self._sections:
  430.             fp.write('[%s]\n' % section)
  431.             for key, value in self._sections[section].items():
  432.                 if key != '__name__':
  433.                     fp.write('%s = %s\n' % (key, str(value).replace('\n', '\n\t')))
  434.                     continue
  435.             
  436.             fp.write('\n')
  437.         
  438.  
  439.     
  440.     def remove_option(self, section, option):
  441.         '''Remove an option.'''
  442.         if not section or section == DEFAULTSECT:
  443.             sectdict = self._defaults
  444.         else:
  445.             
  446.             try:
  447.                 sectdict = self._sections[section]
  448.             except KeyError:
  449.                 raise NoSectionError(section)
  450.  
  451.         option = self.optionxform(option)
  452.         existed = option in sectdict
  453.         if existed:
  454.             del sectdict[option]
  455.         
  456.         return existed
  457.  
  458.     
  459.     def remove_section(self, section):
  460.         '''Remove a file section.'''
  461.         existed = section in self._sections
  462.         if existed:
  463.             del self._sections[section]
  464.         
  465.         return existed
  466.  
  467.     SECTCRE = re.compile('\\[(?P<header>[^]]+)\\]')
  468.     OPTCRE = re.compile('(?P<option>[^:=\\s][^:=]*)\\s*(?P<vi>[:=])\\s*(?P<value>.*)$')
  469.     
  470.     def _read(self, fp, fpname):
  471.         """Parse a sectioned setup file.
  472.  
  473.         The sections in setup file contains a title line at the top,
  474.         indicated by a name in square brackets (`[]'), plus key/value
  475.         options lines, indicated by `name: value' format lines.
  476.         Continuations are represented by an embedded newline then
  477.         leading whitespace.  Blank lines, lines beginning with a '#',
  478.         and just about everything else are ignored.
  479.         """
  480.         cursect = None
  481.         optname = None
  482.         lineno = 0
  483.         e = None
  484.         while True:
  485.             line = fp.readline()
  486.             if not line:
  487.                 break
  488.             
  489.             lineno = lineno + 1
  490.             if line.strip() == '' or line[0] in '#;':
  491.                 continue
  492.             
  493.             if line.split(None, 1)[0].lower() == 'rem' and line[0] in 'rR':
  494.                 continue
  495.             
  496.             if line[0].isspace() and cursect is not None and optname:
  497.                 value = line.strip()
  498.                 if value:
  499.                     cursect[optname] = '%s\n%s' % (cursect[optname], value)
  500.                 
  501.             value
  502.             mo = self.SECTCRE.match(line)
  503.             if mo:
  504.                 sectname = mo.group('header')
  505.                 if sectname in self._sections:
  506.                     cursect = self._sections[sectname]
  507.                 elif sectname == DEFAULTSECT:
  508.                     cursect = self._defaults
  509.                 else:
  510.                     cursect = {
  511.                         '__name__': sectname }
  512.                     self._sections[sectname] = cursect
  513.                 optname = None
  514.                 continue
  515.             if cursect is None:
  516.                 raise MissingSectionHeaderError(fpname, lineno, line)
  517.                 continue
  518.             mo = self.OPTCRE.match(line)
  519.             if mo:
  520.                 (optname, vi, optval) = mo.group('option', 'vi', 'value')
  521.                 if vi in ('=', ':') and ';' in optval:
  522.                     pos = optval.find(';')
  523.                     if pos != -1 and optval[pos - 1].isspace():
  524.                         optval = optval[:pos]
  525.                     
  526.                 
  527.                 optval = optval.strip()
  528.                 if optval == '""':
  529.                     optval = ''
  530.                 
  531.                 optname = self.optionxform(optname.rstrip())
  532.                 cursect[optname] = optval
  533.                 continue
  534.             if not e:
  535.                 e = ParsingError(fpname)
  536.             
  537.             e.append(lineno, repr(line))
  538.         if e:
  539.             raise e
  540.         
  541.  
  542.  
  543.  
  544. class ConfigParser(RawConfigParser):
  545.     
  546.     def get(self, section, option, raw = False, vars = None):
  547.         """Get an option value for a given section.
  548.  
  549.         All % interpolations are expanded in the return values, based on the
  550.         defaults passed into the constructor, unless the optional argument
  551.         `raw' is true.  Additional substitutions may be provided using the
  552.         `vars' argument, which must be a dictionary whose contents overrides
  553.         any pre-existing defaults.
  554.  
  555.         The section DEFAULT is special.
  556.         """
  557.         d = self._defaults.copy()
  558.         
  559.         try:
  560.             d.update(self._sections[section])
  561.         except KeyError:
  562.             if section != DEFAULTSECT:
  563.                 raise NoSectionError(section)
  564.             
  565.         except:
  566.             section != DEFAULTSECT
  567.  
  568.         if vars:
  569.             for key, value in vars.items():
  570.                 d[self.optionxform(key)] = value
  571.             
  572.         
  573.         option = self.optionxform(option)
  574.         
  575.         try:
  576.             value = d[option]
  577.         except KeyError:
  578.             raise NoOptionError(option, section)
  579.  
  580.         if raw:
  581.             return value
  582.         else:
  583.             return self._interpolate(section, option, value, d)
  584.  
  585.     
  586.     def items(self, section, raw = False, vars = None):
  587.         """Return a list of tuples with (name, value) for each option
  588.         in the section.
  589.  
  590.         All % interpolations are expanded in the return values, based on the
  591.         defaults passed into the constructor, unless the optional argument
  592.         `raw' is true.  Additional substitutions may be provided using the
  593.         `vars' argument, which must be a dictionary whose contents overrides
  594.         any pre-existing defaults.
  595.  
  596.         The section DEFAULT is special.
  597.         """
  598.         d = self._defaults.copy()
  599.         
  600.         try:
  601.             d.update(self._sections[section])
  602.         except KeyError:
  603.             if section != DEFAULTSECT:
  604.                 raise NoSectionError(section)
  605.             
  606.         except:
  607.             section != DEFAULTSECT
  608.  
  609.         if vars:
  610.             for key, value in vars.items():
  611.                 d[self.optionxform(key)] = value
  612.             
  613.         
  614.         options = d.keys()
  615.         if '__name__' in options:
  616.             options.remove('__name__')
  617.         
  618.  
  619.     
  620.     def _interpolate(self, section, option, rawval, vars):
  621.         value = rawval
  622.         depth = MAX_INTERPOLATION_DEPTH
  623.         while depth:
  624.             depth -= 1
  625.             if '%(' in value:
  626.                 value = self._KEYCRE.sub(self._interpolation_replace, value)
  627.                 
  628.                 try:
  629.                     value = value % vars
  630.                 except KeyError:
  631.                     e = None
  632.                     raise InterpolationMissingOptionError(option, section, rawval, e[0])
  633.                 except:
  634.                     None<EXCEPTION MATCH>KeyError
  635.                 
  636.  
  637.             None<EXCEPTION MATCH>KeyError
  638.             break
  639.         if '%(' in value:
  640.             raise InterpolationDepthError(option, section, rawval)
  641.         
  642.         return value
  643.  
  644.     _KEYCRE = re.compile('%\\(([^)]*)\\)s|.')
  645.     
  646.     def _interpolation_replace(self, match):
  647.         s = match.group(1)
  648.         if s is None:
  649.             return match.group()
  650.         else:
  651.             return '%%(%s)s' % self.optionxform(s)
  652.  
  653.  
  654.  
  655. class SafeConfigParser(ConfigParser):
  656.     
  657.     def _interpolate(self, section, option, rawval, vars):
  658.         L = []
  659.         self._interpolate_some(option, L, rawval, section, vars, 1)
  660.         return ''.join(L)
  661.  
  662.     _interpvar_match = re.compile('%\\(([^)]+)\\)s').match
  663.     
  664.     def _interpolate_some(self, option, accum, rest, section, map, depth):
  665.         if depth > MAX_INTERPOLATION_DEPTH:
  666.             raise InterpolationDepthError(option, section, rest)
  667.         
  668.         while rest:
  669.             p = rest.find('%')
  670.             if p < 0:
  671.                 accum.append(rest)
  672.                 return None
  673.             
  674.             if p > 0:
  675.                 accum.append(rest[:p])
  676.                 rest = rest[p:]
  677.             
  678.             c = rest[1:2]
  679.             None if c == '%' else '%' in v
  680.             raise InterpolationSyntaxError(option, section, "'%%' must be followed by '%%' or '(', found: %r" % (rest,))
  681.  
  682.     
  683.     def set(self, section, option, value):
  684.         '''Set an option.  Extend ConfigParser.set: check for string values.'''
  685.         if not isinstance(value, basestring):
  686.             raise TypeError('option values must be strings')
  687.         
  688.         ConfigParser.set(self, section, option, value)
  689.  
  690.  
  691.